home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 August: Tool Chest / Dev.CD Aug 95 TC / Dev.CD Aug 95 TC.toast / Tool Chest / Interfaces / UniversalInterfaces 2.0 / PInterfaces / CodeFragments.p < prev    next >
Encoding:
Text File  |  1995-04-18  |  8.3 KB  |  310 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        CodeFragments.p
  3.  
  4.      Contains:    Code Fragment Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT CodeFragments;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __CODEFRAGMENTS__}
  30. {$SETC __CODEFRAGMENTS__ := 1}
  31.  
  32. {$I+}
  33. {$SETC CodeFragmentsIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __FILES__}
  43. {$I Files.p}
  44. {$ENDC}
  45. {    MixedMode.p                                                    }
  46. {    OSUtils.p                                                    }
  47. {        Memory.p                                                }
  48.  
  49. {$PUSH}
  50. {$ALIGN MAC68K}
  51. {$LibExport+}
  52.  
  53. CONST
  54.     kCFragResourceType            = 'cfrg';
  55.     kCFragResourceID            = 0;
  56.     kCFragLibraryFileType        = 'shlb';
  57.  
  58.     
  59. TYPE
  60.     CFragArchitecture = OSType;
  61.  
  62.  
  63. CONST
  64.     kPowerPCCFragArch            = 'pwpc';
  65.     kMotorola68KCFragArch        = 'm68k';
  66.     kAnyCFragArch                = $3F3F3F3F;
  67.  
  68. {$IFC GENERATINGPOWERPC }
  69.     kCurrentCFragArch            = kPowerPCCFragArch;
  70.  
  71. {$ENDC}
  72. {$IFC GENERATING68K }
  73.     kCurrentCFragArch            = kMotorola68KCFragArch;
  74.  
  75. {$ENDC}
  76.     
  77. TYPE
  78.     CFragConnectionID = UInt32;
  79.  
  80.     CFragClosureID = UInt32;
  81.  
  82.     CFragContextID = UInt32;
  83.  
  84.     CFragContainerID = UInt32;
  85.  
  86.     
  87. TYPE
  88.     CFragLoadOptions = UInt32;
  89.  
  90.  
  91. CONST
  92.     kLoadCFrag                    = $01;                            { Try to use existing copy, load if not found.}
  93.     kFindCFrag                    = $02;                            { Try find an existing copy, don't load if not found.}
  94.     kNewCFragCopy                = $05;                            { Load a new copy whether one already exists or not.}
  95.     kInplaceCFrag                = $80;                            { Use data sections directly in the container.}
  96.  
  97.     kUnresolvedCFragSymbolAddress = 0;
  98.  
  99.     
  100. TYPE
  101.     CFragSymbolClass = UInt8;
  102.  
  103.  
  104. CONST
  105.     kCodeCFragSymbol            = 0;
  106.     kDataCFragSymbol            = 1;
  107.     kTVectorCFragSymbol            = 2;
  108.     kTOCCFragSymbol                = 3;
  109.     kGlueCFragSymbol            = 4;
  110.  
  111.     
  112. TYPE
  113.     CFragUsage = UInt8;
  114.  
  115.  
  116. CONST
  117.     kImportLibraryCFrag            = 0;                            { Standard CFM import library.}
  118.     kApplicationCFrag            = 1;                            { Macintosh application.}
  119.     kDropInAdditionCFrag        = 2;                            { Private extension to an application or library.}
  120.  
  121.     kIsCompleteCFrag            = 0;                            { A "base" fragment, not an update.}
  122.     kFirstCFragUpdate            = 1;                            { The first update, others are numbered 2, 3, ...}
  123.  
  124.     
  125. TYPE
  126.     CFragLocatorKind = UInt8;
  127.  
  128.  
  129. CONST
  130.     kMemoryCFragLocator            = 0;                            { Container is already addressable.}
  131.     kDataForkCFragLocator        = 1;                            { Container is in a file's data fork.}
  132.     kResourceCFragLocator        = 2;                            { Container is in a file's resource fork.}
  133.     kByteStreamCFragLocator        = 3;                            { Container is in a given file fork as a byte stream.}
  134.  
  135.     kCFragGoesToEOF                = 0;
  136.  
  137.  
  138. TYPE
  139.     CFragOldMemoryLocator = PACKED RECORD
  140.         address:                LogicalAddress;
  141.         length:                    UInt32;
  142.         inPlace:                BOOLEAN;
  143.         reserved3a:                ARRAY [0..2] OF UInt8;                    { ! Do not use this!}
  144.     END;
  145.  
  146.     CFragHFSDiskFlatLocator = RECORD
  147.         fileSpec:                FSSpecPtr;
  148.         offset:                    UInt32;
  149.         length:                    UInt32;
  150.     END;
  151.  
  152. { ! This must have a file specification at the same offset as a data fork locator!}
  153.     CFragHFSSegmentedLocator = PACKED RECORD
  154.         fileSpec:                FSSpecPtr;
  155.         rsrcType:                OSType;
  156.         rsrcID:                    SInt16;
  157.         reserved2a:                UInt16;                                    { ! Do not use this!}
  158.     END;
  159.  
  160.     CFragHFSLocator = RECORD
  161.         where:                    SInt32;                                    { Really of type CFragLocatorKind.}
  162.         CASE INTEGER OF
  163.         0: (
  164.             onDisk:                        CFragHFSDiskFlatLocator;            { First so debugger shows this form.}
  165.            );
  166.         1: (
  167.             inMem:                        CFragOldMemoryLocator;
  168.            );
  169.         2: (
  170.             inSegs:                        CFragHFSSegmentedLocator;
  171.            );
  172.     END;
  173.  
  174.     CFragHFSLocatorPtr = ^CFragHFSLocator;
  175.  
  176. { -------------------------------------------------------------------------------------------}
  177. { The parameter block passed to fragment initialization functions.  The locator and name}
  178. { pointers are valid only for the duration of the initialization routine.  I.e. if you want}
  179. { to save the locator or name, save the contents, not the pointers.  Initialization routines}
  180. { take one parameter, a pointer to the parameter block, and return a success/failure result.}
  181. { ! Note that the initialization function returns an OSErr.  Any result other than noErr will}
  182. { ! cause the entire load to be aborted at that point.}
  183.     CFragInitBlock = RECORD
  184.         contextID:                CFragContextID;
  185.         closureID:                CFragClosureID;
  186.         connectionID:            CFragConnectionID;
  187.         fragLocator:            CFragHFSLocator;
  188.         libName:                StringPtr;
  189.         reserved4a:                UInt32;                                    { ! Do not use this!}
  190.         reserved4b:                UInt32;                                    { ! Do not use this!}
  191.         reserved4c:                UInt32;                                    { ! Do not use this!}
  192.         reserved4d:                UInt32;                                    { ! Do not use this!}
  193.     END;
  194.  
  195.     CFragInitBlockPtr = ^CFragInitBlock;
  196.  
  197.     CFragInitFunction = ProcPtr;  { FUNCTION ((CONST)VAR theInitBlock: CFragInitBlock): OSErr; }
  198.  
  199.     CFragTermRoutine = ProcPtr;  { PROCEDURE ; }
  200.  
  201.     CFragInitFunctionPtr = ^CFragInitFunction;
  202.  
  203.     CFragTermRoutinePtr = ^CFragTermRoutine;
  204.  
  205. { §}
  206. { ===========================================================================================}
  207. { Routines}
  208. { ========}
  209.  
  210. FUNCTION GetSharedLibrary(libName: ConstStr63Param; archType: OSType; loadFlags: CFragLoadOptions; VAR connID: CFragConnectionID; VAR mainAddr: Ptr; VAR errMessage: Str255): OSErr;
  211.     {$IFC NOT GENERATINGCFM}
  212.     INLINE $3F3C, $0001, $AA5A;
  213.     {$ENDC}
  214. FUNCTION GetDiskFragment({CONST}VAR fileSpec: FSSpec; offset: UInt32; length: UInt32; fragName: ConstStr63Param; loadFlags: CFragLoadOptions; VAR connID: CFragConnectionID; VAR mainAddr: Ptr; VAR errMessage: Str255): OSErr;
  215.     {$IFC NOT GENERATINGCFM}
  216.     INLINE $3F3C, $0002, $AA5A;
  217.     {$ENDC}
  218. FUNCTION GetMemFragment(memAddr: UNIV Ptr; length: UInt32; fragName: ConstStr63Param; loadFlags: CFragLoadOptions; VAR connID: CFragConnectionID; VAR mainAddr: Ptr; VAR errMessage: Str255): OSErr;
  219.     {$IFC NOT GENERATINGCFM}
  220.     INLINE $3F3C, $0003, $AA5A;
  221.     {$ENDC}
  222. FUNCTION CloseConnection(VAR connID: CFragConnectionID): OSErr;
  223.     {$IFC NOT GENERATINGCFM}
  224.     INLINE $3F3C, $0004, $AA5A;
  225.     {$ENDC}
  226. FUNCTION FindSymbol(connID: CFragConnectionID; symName: ConstStr255Param; VAR symAddr: Ptr; VAR symClass: CFragSymbolClass): OSErr;
  227.     {$IFC NOT GENERATINGCFM}
  228.     INLINE $3F3C, $0005, $AA5A;
  229.     {$ENDC}
  230. FUNCTION CountSymbols(connID: CFragConnectionID; VAR symCount: LONGINT): OSErr;
  231.     {$IFC NOT GENERATINGCFM}
  232.     INLINE $3F3C, $0006, $AA5A;
  233.     {$ENDC}
  234. FUNCTION GetIndSymbol(connID: CFragConnectionID; symIndex: LONGINT; VAR symName: Str255; VAR symAddr: Ptr; VAR symClass: CFragSymbolClass): OSErr;
  235.     {$IFC NOT GENERATINGCFM}
  236.     INLINE $3F3C, $0007, $AA5A;
  237.     {$ENDC}
  238. {$IFC OLDROUTINENAMES }
  239.     
  240. TYPE
  241.     ConnectionID = CFragConnectionID;
  242.  
  243.     LoadFlags = CFragLoadOptions;
  244.  
  245.     SymClass = CFragSymbolClass;
  246.  
  247.     MemFragment = CFragOldMemoryLocator;
  248.  
  249.     DiskFragment = CFragHFSDiskFlatLocator;
  250.  
  251.     SegmentedFragment = CFragHFSSegmentedLocator;
  252.  
  253.     FragmentLocator = CFragHFSLocator;
  254.  
  255.     FragmentLocatorPtr = CFragHFSLocatorPtr;
  256.  
  257.     InitBlock = CFragInitBlock;
  258.  
  259.     InitBlockPtr = CFragInitBlockPtr;
  260.  
  261.     ConnectionInitializationRoutine = CFragInitFunction;
  262.  
  263.     ConnectionTerminationRoutine = CFragTermRoutine;
  264.  
  265.  
  266. CONST
  267.     kPowerPCArch                = kPowerPCCFragArch;
  268.     kMotorola68KArch            = kMotorola68KCFragArch;
  269.     kAnyArchType                = kAnyCFragArch;
  270.     kNoLibName                    = 0;
  271.     kNoConnectionID                = 0;
  272.     kLoadLib                    = kLoadCFrag;
  273.     kFindLib                    = kFindCFrag;
  274.     kLoadNewCopy                = kNewCFragCopy;
  275.     kUseInPlace                    = kInplaceCFrag;
  276.     kCodeSym                    = kCodeCFragSymbol;
  277.     kDataSym                    = kDataCFragSymbol;
  278.     kTVectSym                    = kTVectorCFragSymbol;
  279.     kTOCSym                        = kTOCCFragSymbol;
  280.     kGlueSym                    = kGlueCFragSymbol;
  281.     kInMem                        = kMemoryCFragLocator;
  282.     kOnDiskFlat                    = kDataForkCFragLocator;
  283.     kOnDiskSegmented            = kResourceCFragLocator;
  284.     kIsLib                        = kImportLibraryCFrag;
  285.     kIsApp                        = kApplicationCFrag;
  286.     kIsDropIn                    = kDropInAdditionCFrag;
  287.     kFullLib                    = kIsCompleteCFrag;
  288.     kUpdateLib                    = kFirstCFragUpdate;
  289.     kWholeFork                    = kCFragGoesToEOF;
  290.     kCFMRsrcType                = kCFragResourceType;
  291.     kCFMRsrcID                    = kCFragResourceID;
  292.     kSHLBFileType                = kCFragLibraryFileType;
  293.     kUnresolvedSymbolAddress    = kUnresolvedCFragSymbolAddress;
  294.  
  295.     kPowerPC                    = kPowerPCCFragArch;
  296.     kMotorola68K                = kMotorola68KCFragArch;
  297.  
  298. {$ENDC}
  299.  
  300. {$ALIGN RESET}
  301. {$POP}
  302.  
  303. {$SETC UsingIncludes := CodeFragmentsIncludes}
  304.  
  305. {$ENDC} {__CODEFRAGMENTS__}
  306.  
  307. {$IFC NOT UsingIncludes}
  308.  END.
  309. {$ENDC}
  310.